home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / utilities / gadoc.lha / gadoc.c / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-02  |  17.0 KB  |  645 lines
  1.  
  2.  /***********************************************************************
  3.  *                                    *
  4.  * Autor    : Gerhard Leibrock, Neuhäuselerstr. 12, 66459 Kirkel    *
  5.  *                                    *
  6.  * Programmname    :GAdoc                            *
  7.  *                                    *
  8.  * Version    : 1.0        **    Fertig am : 01.03.1995        *
  9.  *                                    *
  10.  * Programmart    :                            *
  11.  *                                    *
  12.  * Aufruf    : GAdoc                            *
  13.  *                                    *
  14.  * Rückgabewerte: int Werte                        *
  15.  *                                    *
  16.  *        NULL  : Arbeit erfolgreich beendet            *
  17.  *        sonst : Arbeit abgebrochen (Speicher knapp, etc.)    *
  18.  *                                    *
  19.  * Beschreibung    :                            *
  20.  *                                    *
  21.  * Anfangsdatum    : 10.02.1995    ##    letzte Änderung : 01.03.1995    *
  22.  *                                    *
  23.  ***********************************************************************/
  24.  
  25. char *VER = "$VER: GAdoc 1.1 (c) Gerhard Leibrock (01.03.95)";
  26.  
  27.  
  28. #include <stdio.h>
  29. #include <string.h>
  30. #include <stdlib.h>
  31. #include <time.h>
  32.  
  33.  
  34. typedef enum{FALSE, TRUE} BOOL;
  35.  
  36.  
  37. void WriteTexinfo
  38.     (FILE *fptr, char *filename, char *author,
  39.      char *project, char *version, char *copyright, BOOL amiga_support)
  40. {
  41.   /* To obtain the system-time -> Included as the date of extraction */
  42.   time_t t;
  43.  
  44.   /* To eliminate path-symbols like `:' or `/'; */
  45.   int i;
  46.  
  47.   time(&t);
  48.  
  49.  
  50.   for(i=strlen(filename)-1; i>=0; i--)
  51.     if(filename[i] == ':' || filename[i]=='/') break;
  52.  
  53.   if(amiga_support) fputs("\\input amigatexinfo\n", fptr);
  54.   fputs("\\input texinfo @c -*-Texinfo-*-\n\n",    fptr);
  55.   fprintf(fptr,
  56.     "@setfilename %s.guide\n"
  57.     "@settitle Autodocs for %s\n"
  58.     "@finalout\n@setchapternewpage on\n\n"
  59.     "@titlepage\n@title Autodocs for %s\n"
  60.     "@subtitle Documentation taken from source code\n"
  61.     "@subtitle \n"
  62.     "@subtitle Version %s\n"
  63.     "@subtitle \n"
  64.     "@subtitle Printed version\n"
  65.     "@subtitle \n"
  66.     "@subtitle Extracted %s\n"
  67.     "@subtitle \n"
  68.     "@author %s\n\n"
  69.     "@page\n@vskip 0pt plus 1filll\n"
  70.     "Copyright @copyright{} by %s\n"
  71.     "@end titlepage\n\n"
  72.     "@ifinfo\n@node Top\n@top\n@unnumbered\n\n"
  73.     "@center Autodocs for %s\n"
  74.     "Written by %s\n"
  75.     "@copyright{} Copyright by %s\n"
  76.     "Documentation taken directly from source code\n\n"
  77.     "Extracted %s\n\n"
  78. #if 0
  79.     "Docs generated using GAdoc, (c) by Gerhard Leibrock, Feb 1995\n\n"
  80. #endif
  81.     "@end ifinfo\n\n\n"
  82.     "@menu\n",
  83.          &filename[i+1], project, project, version, ctime(&t), author, copyright,
  84.     project, author, copyright, ctime(&t));
  85. }
  86.  
  87. int main(int argc, char *argv[])
  88. {
  89.   FILE *ein;
  90.   FILE *aus_menue, *aus_daten;
  91.  
  92.   int i, j;
  93.  
  94.   char fname[64];
  95.  
  96.   #define MAX_LINE_LENGTH 80
  97.   char zk[MAX_LINE_LENGTH], zk1[MAX_LINE_LENGTH], zk2[MAX_LINE_LENGTH];
  98.  
  99.   /* Name des Programmautors */
  100.   char author[50];
  101.   /* Wie heisst dads Projekt? */
  102.   char project[50];
  103.   /* Welche Version hat es? */
  104.   char version[50];
  105.   /* Wer hat das Copyright? */
  106.   char copyright[50];
  107.  
  108.  
  109.  
  110.   unsigned int zeile = NULL;
  111.  
  112.   BOOL autodoc_mode=FALSE;
  113.  
  114.   /* Schluesselworte fuer Auto-DOCS */
  115.   char *keywords[] = {"NAME", "SYNOPSIS", "FUNCTION", "INPUTS", "RESULT",
  116.   "EXAMPLE", "NOTES", "BUGS"};
  117.   BOOL autodoc = FALSE;
  118.   BOOL first_key = FALSE;
  119.   BOOL see_also = FALSE;    /* Im @ref{} Modus */
  120.   BOOL see_also_found = FALSE;    /* SEE ALSO schon vorgekommen */
  121.   BOOL key_found = FALSE;
  122.   BOOL key[sizeof(keywords) / sizeof(char**)];
  123.  
  124.   /* Programminteren Schluesselwoerter */
  125.   char *internal_keywords[] = {"NAME", "COPYRIGHT", "FUNCTION", "AUTHOR",
  126.   "NOTES", "VERSION"};
  127.   BOOL internal_key[sizeof(internal_keywords) / sizeof(char**)];
  128.   BOOL internal = FALSE; /* Internal schon mal aufgerufen? */
  129.   BOOL internal_mode = FALSE;
  130.   /* Zum Aussteigen beim Einlesen der Datei bei Endkennung */
  131.   BOOL internal_ende = FALSE;
  132.  
  133.   /* */
  134.   BOOL first_internal = FALSE;
  135.   /* Zuletzt aktives Schluesselwort */
  136.   int last_key = -1;
  137.  
  138.   /* Extrahieren der als intern deklarierten Docs? */
  139.   BOOL extract_internal = FALSE;
  140.   /* Include amiga support? */
  141.   BOOL amiga_support = FALSE;
  142.  
  143.   char *token; /* Zum Aufsplitten der Eingabe-Datei */
  144.  
  145.   BOOL convert_comment = FALSE;
  146.  
  147.  
  148.   if(argc<3 || argc>6)
  149.   {
  150.     puts("This prgram extracts the AutoDOCs from your source-files\n"
  151.          "and produces two TeXinfo-files out of it:\n"
  152.          "<texinfo_file>.menu AND <texinfo_file>.data\n"
  153.          "The *.menu file is the main part, use it with makeinfo.");
  154.     printf("Syntax:\n"
  155.            "\t%s <source> <texinfo_file> [-i] [-amiga] [-c]\n"
  156.            "\t -i:     Also extract internal documentation\n"
  157.            "\t -c:     Convert \\* to /* and *\\ to */\n"
  158.            "\t -amiga: Include amiga support for texinfo\n"
  159.            "(c) Gerhard Leibrock, 1995\n", argv[0]);
  160.     printf("Warning: Lines are limited to %ld chars!\n", sizeof(zk));
  161.     exit(0);
  162.   }
  163.  
  164.   /* Testen, ob der Benutzer AUCH die als INTERN deklarierten Autodocs
  165.      erhalten moechte */
  166.   if(argc>=4)
  167.     for(i=3; i<argc; i++)
  168.     {
  169.       if(!strcmp(argv[i], "-i"))
  170.       {
  171.         if(extract_internal)
  172.         {
  173.       printf("-i: Specified twice (See argument #%d)\n", i+1);
  174.       exit(0);
  175.         }
  176.         else
  177.           extract_internal = TRUE;
  178.       }
  179.       else if(!strcmp(argv[i], "-amiga"))
  180.       {
  181.         if(amiga_support)
  182.         {
  183.       printf("-a: Specified twice (See argument #%d)\n", i+1);
  184.       exit(0);
  185.         }
  186.         else
  187.           amiga_support = TRUE;
  188.       }
  189.       else if(!strcmp(argv[i], "-c"))
  190.       {
  191.         if(convert_comment)
  192.         {
  193.       printf("-c: Specified twice (See argument #%d)\n", i+1);
  194.       exit(0);
  195.         }
  196.         else
  197.           convert_comment = TRUE;
  198.       }
  199.       else
  200.       {
  201.         printf("Unknown argument: %s\n", argv[i]);
  202.         exit(0);
  203.       }
  204.     } /* Schleife ueber die Argumente beim Aufruf */
  205.  
  206.  
  207.   /* Open the source-file */
  208.   if(!(ein=fopen(argv[1], "r")))
  209.   {
  210.     printf("Could not open file ``%s''.\n", argv[1]);
  211.     exit(0);
  212.   }
  213.  
  214.   /* Open the output file, which contains the document description and
  215.      toc */
  216.   strcpy(fname, argv[2]); strcat(fname, ".menu");
  217.   if(!(aus_menue=fopen(fname, "w")))
  218.   {
  219.     printf("Could not open file %s.\n", fname);
  220.     fclose(ein);
  221.     exit(0);
  222.   }
  223.  
  224.   /* Open the file, which will contain the function descriptions,
  225.      ``fname'' will be used later agin and contains the filename */
  226.   strcpy(fname, argv[2]); strcat(fname, ".data");
  227.   if(!(aus_daten=fopen(fname, "w")))
  228.   {
  229.     printf("Could not open file %s!\n", fname);
  230.     fclose(ein); fclose(aus_menue);
  231.     exit(0);
  232.   }
  233.  
  234.  
  235.   for(i=0; i<sizeof(keywords) / sizeof(char**); i++) key[i]=FALSE;
  236.   for(i=0; i<sizeof(internal_keywords) / sizeof(char**); i++)
  237.     internal_key[i]=FALSE;
  238.  
  239.  
  240.   /* Vorbelegen der Variablen */
  241.   strncpy(author, "Unknown", 50);
  242.   strncpy(project, argv[1], 50);
  243.   strcpy(version, "0.0");
  244.  
  245.  
  246.   while ( fgets(zk, sizeof(zk), ein) )
  247.   {
  248.     zeile++;
  249.  
  250.     /* Wir sind im Autodoc-Modus */
  251.     if(autodoc_mode)
  252.     {
  253.       if(!strncmp(zk, "*********", 9) || !strncmp(zk, ";********", 9)
  254.     ||!strncmp(zk, "%********", 9) )
  255.       {/* Endkennung erreicht */
  256.     /* Testen, ob es Schluesselwoerter gibt, zu denen nichts
  257.        geschrieben wurde und zuruecksetzen */
  258.     for(i=0; i<sizeof(keywords) / sizeof(char**); i++)
  259.     {
  260.       if(!key[i]) fprintf(aus_daten, "\n@code{%s}\n", keywords[i]);
  261.       key[i]=FALSE;
  262.     }
  263.  
  264.     /* SEE ALSO schon aufgetaucht? */
  265.     if(!see_also_found) fputs("\n@code{SEE ALSO}\n", aus_daten);
  266.  
  267.     key_found = FALSE;
  268.     first_key=FALSE;
  269.     autodoc_mode = FALSE;
  270.     if(!see_also) fputs("@end example\n", aus_daten);
  271.     see_also = FALSE; see_also_found = FALSE;
  272.     fputs("\n\n\n", aus_daten);
  273.     /* Testen, ob es Schluesselwoerter gibt, zu denen nichts
  274.        geschrieben wurde. */
  275.      }
  276.       else /* Teste, auf Anfang fuer Autodoc-Modus */
  277.       {
  278.         key_found = FALSE;
  279.     /* Keine Endkennung, vielleicht aber ein neues Schlüsselwort? */
  280.  
  281.     /* Ueberlese erstes Zeichen und alle TABs, Leerzeichen */
  282.     strcpy(zk1, zk);
  283.     token = strtok(&zk[1], " \t\n");
  284.  
  285.         if(token)
  286.         {
  287.       if(!strcmp(token, "SEE"))
  288.       {
  289.         token = strtok(NULL," \t\n");
  290.         if(!strcmp(token, "ALSO"))
  291.         {
  292.           if(see_also_found)
  293.           {
  294.         printf( "Error Line %u: Either keyword SEE ALSO used twice"
  295.             "or in wrong order.\n", zeile);
  296.         exit(0);
  297.           }
  298.           /* Nun setzen wir alle Kennungen fuer Schluesselwoerter auf
  299.              gefunden, falls diese noch nicht gefunden worden sind, da
  300.              SEE ALSO das letzte zu akzeptierende Schluesselwort ist.
  301.          Ausserdem schreiben wir die Schluesselworte, da alle
  302.          vorkommen sollen */
  303.           for(i=0; i<sizeof(keywords) / sizeof(char**); i++)
  304.           {
  305.         if(!key[i]) fprintf(aus_daten, "\n@code{%s}\n", keywords[i]);
  306.         key[i]=TRUE;
  307.           }
  308.  
  309.           /* Schluesselwort "SEE ALSO" */
  310.           if(first_key) fputs("@end example\n", aus_daten);
  311.           first_key=TRUE;
  312.           key_found=TRUE;
  313.           see_also = TRUE; see_also_found = TRUE;
  314.           strcpy(zk1, "SEE ALSO");
  315.         }
  316.       }
  317.       else {
  318.         for(i=0; i< sizeof(keywords) / sizeof(char**); i++)
  319.         {
  320.           if(!strcmp(token, keywords[i]))
  321.           {
  322.             if(key[i] == TRUE)
  323.             {
  324.           printf("Error Line %u: Either keyword %s used twice"
  325.              "               or in wrong order\n",
  326.             zeile, keywords[i]);
  327.           exit(0);
  328.             }
  329.             /* Alle Schluesselwoerter, die vor diesem in der Reihenfolge
  330.                stehen, werden als belegt gekennzeichnet */
  331.         for(j=0; j<i; j++)
  332.         {
  333.           if(!key[j]) fprintf(aus_daten, "\n@code{%s}\n", keywords[j]);
  334.           key[j]=TRUE;
  335.         }
  336.         key[i]=TRUE;
  337.             if(first_key) fputs("@end example\n", aus_daten);
  338.             first_key=TRUE;
  339.             key_found=TRUE;
  340.             see_also = FALSE;
  341.             strcpy(zk1, keywords[i]);
  342.             break;
  343.           }
  344.         } /* Suche nach Keyword */
  345.       } /* ELSE */
  346.     }
  347.     if(!key_found) {
  348.       if(see_also)
  349.       {
  350.         token = strtok(&zk[1], " ,\t\n");
  351.         if(token) strcpy(zk1, token);
  352.         else      zk1[0] = '\0';
  353.         while(token != NULL)
  354.         {
  355.           /* Ueberlesen des Textes vor ``/'' */
  356.           for(i=0; i<strlen(token); i++)
  357.           {
  358.             if(token[i]=='/') {
  359.               zk1[i]=NULL;
  360.               strcpy(zk2, &token[i+1]);
  361.               break; }
  362.           }
  363.  
  364.           /* Ist zk1 != Dateiname, dann wird ein Objekt ausserhalb
  365.              referenziert, sonst koennen wir den Dateinamen weglassen */
  366.           if(!strcmp(zk1, argv[1]))
  367.           {
  368.             fprintf(aus_daten, "@ref{%s}.\n", zk2);
  369.           }
  370.           else
  371.           {
  372.         /* Nun referenzieren in eine andere Datei */
  373.         fprintf(aus_daten, "@xref{%s, , %s, %s, Autodoc-file %s}.\n",
  374.             zk2, zk2, zk1, zk1);
  375.           }
  376.  
  377.           token = strtok(NULL," ,\t\n");
  378.         }
  379.       }
  380.       else
  381.       {
  382.         if(convert_comment)
  383.         {
  384.           for(i=0; i<strlen(zk1); i++)
  385.             if(zk1[i] == '\\') zk1[i] = '/';
  386.  
  387.         }
  388.         fputs(&zk1[1], aus_daten);
  389.       }
  390.     }
  391.       /* Wir ignorieren das erste Zeichen links */
  392.     else
  393.     {
  394.       fprintf(aus_daten, "\n@code{%s}\n", zk1);
  395.       if(!see_also)  fputs("\n@example\n", aus_daten);
  396.       key_found = FALSE;
  397.     }
  398.       } /* keine Endkennung */
  399.     }
  400.     else /* Nicht im Autodoc-Modus */
  401.     { /* Autodoc-Modus startet mit einer Zeile, bei der das erste Zeichen
  402.      keine Rolle spielt, dann aber 6 '*' folgen, dann durch ein
  403.      Leerzeichen getrennt der Name der Funktion und dann durch ein
  404.      Leerzeichen getrennt beliebige Zeichen */
  405.       i = sscanf(&zk[1], "****** %s %s", zk1, zk2);
  406.       /* zk1: Name der Funktion, zk2 -> Beliebiger Rest */
  407.       if(i>=1) /* Anfangskennzeichen */
  408.       {
  409.     if(!autodoc) /* Erster Eintrag? */
  410.     {
  411.       autodoc = TRUE;
  412.       WriteTexinfo(
  413.         aus_menue, argv[2], author, project, version,
  414.         copyright, amiga_support);
  415.     }
  416.     autodoc_mode = TRUE;
  417.  
  418.         /* Ueberlese den Teil vor ``/'' */
  419.         token = strtok(zk1, "/");
  420.         token = strtok(NULL, " \n\t");
  421.  
  422.     /* Menue-Datei */
  423.     fprintf(aus_menue, "* %s::\n", token);
  424.     fprintf(aus_daten, "@node %s\n"
  425.                "@chapter %s\n"
  426.                "@findex %s\n\n",
  427.                 token, token, token);
  428.     
  429.       }
  430.  
  431.       /* Modus fuer die internen Funktionen */
  432.       i = sscanf(&zk[1], "****i* %s %s", zk1, zk2);
  433.       /* zk1: Name der Funktion, zk2 -> Beliebiger Rest */
  434.       if(i>=1) /* Anfangskennzeichen */
  435.       {
  436.     /* Wir sollen auch die internen Docs extrahieren? */
  437.     if(extract_internal) 
  438.     {
  439.       if(!autodoc)    /* Erster Eintrag ueberhaupt? */
  440.       {
  441.         autodoc = TRUE;
  442.         WriteTexinfo(
  443.         aus_menue, argv[2], author, project, version,
  444.         copyright, amiga_support);
  445.       }
  446.       autodoc_mode = TRUE;
  447.  
  448.       /* Ueberlese den Teil vor ``/'' */
  449.       token = strtok(zk1, "/");
  450.       token = strtok(NULL, " \n\t");
  451.  
  452.       /* Menue-Datei */
  453.       fprintf(aus_menue, "* %s:: Internal function\n", token);
  454.       fprintf(aus_daten, "@node %s\n"
  455.                "@chapter %s\n"
  456.                "@findex %s (Internal function)\n\n"
  457.                "@center ONLY FOR INTERNAL USE: @b{%s}\n\n",
  458.                 token, token, token, token);
  459.     }
  460.     else /* ueberlesen der INTERNEN Funktionsdokumentation */
  461.     {
  462.       BOOL haben_ende = FALSE;
  463.       while ( fgets(zk, sizeof(zk), ein) && !haben_ende )
  464.       {
  465.         zeile++;
  466.             if(!strncmp(zk, "*********", 9) || !strncmp(zk, ";********", 9)
  467.          ||!strncmp(zk, "%********", 9) )
  468.          {
  469.         haben_ende = TRUE;
  470.         break;
  471.          }
  472.       } /* fgets() */
  473.       if(!haben_ende)
  474.       {
  475.         printf("Error: End of file occured during internal docs.\n");
  476.         exit(0);
  477.       }
  478.     } /* Ueberlesen der internen Dokumentation */
  479.       } /* BLOCK zum Lesen der internen Dokumentation */
  480.  
  481.       /* Ausfuellen der Slots (Fuer AUTHOR, etc): */
  482.       i = sscanf(&zk[1], "****h* %s %s", zk1, zk2);
  483.       /* zk1: Name der Funktion, zk2 -> Beliebiger Rest */
  484.       if(i>=1) /* Anfangskennzeichen */
  485.       {
  486.     internal_ende = FALSE;
  487.  
  488.     if(autodoc) {
  489.       printf("Error Line %u: Header specified after autodocs.\n",
  490.         zeile);
  491.       exit(0); }
  492.  
  493.         if(internal) {
  494.       printf("Error Line %u: Second time header gets specified.\n", zeile);
  495.       exit(0); }
  496.       
  497.         /* Ueberlese den Teil vor ``/'' */
  498.         token = strtok(zk1, "/");
  499.         token = strtok(NULL, " \n\t");
  500.  
  501.     /* Menue-Datei */
  502.     fprintf(aus_daten, "@node About_%s\n"
  503.                "@chapter About_%s\n"
  504.                "@findex About_%s\n\n",
  505.                 token, token, token);
  506.  
  507.         strcpy(zk2, token);
  508.     /* Nun solange lesen, bis wir die internal-Sachen abgearbeitet haben */
  509.     while ( fgets(zk, sizeof(zk), ein) && !internal_ende )
  510.     {
  511.       zeile++;
  512.           if(!strncmp(zk, "*********", 9) || !strncmp(zk, ";********", 9)
  513.        ||!strncmp(zk, "%********", 9) )
  514.           {/* Endkennung erreicht */
  515.         for(i=0; i<sizeof(internal_keywords) / sizeof(char**); i++)
  516.         internal_key[i]=FALSE;
  517.  
  518.         internal_mode = FALSE;
  519.         internal = TRUE;
  520.         if(!see_also) fputs("@end example\n", aus_daten);
  521.         fputs("\n\n\n", aus_daten);
  522.         internal_ende = TRUE;
  523.           }
  524.           else /* Teste, auf Anfang fuer Internal-Modus */
  525.           {
  526.         /* Ueberlese erstes Zeichen und alle TABs, Leerzeichen */
  527.         strcpy(zk1, zk);
  528.         token = strtok(&zk[1], " \t\n");
  529.  
  530.         /* Schleifenvariable i dient spaeter als Indikator fuer
  531.            das Auffinden eines Schluesselwortes. Mit dem Setzen auf
  532.            einen Wert ausserhalb des Schluesselwort-Bereichs setzen
  533.            wir den Test fuers Finden auf FALSE */
  534.         i=sizeof(internal_keywords) / sizeof(char**);
  535.  
  536.             if(token)
  537.             {
  538.           for(i=0; i< sizeof(internal_keywords) / sizeof(char**); i++)
  539.           {
  540.             if(!strcmp(token, internal_keywords[i]))
  541.             {
  542.           last_key = i;
  543.               if(internal_key[i] == TRUE)
  544.               {
  545.             printf("Error Line %u: Keyword %s used twice.\n",
  546.               zeile, keywords[i]);
  547.             exit(0);
  548.               }
  549.               if(first_internal) fputs("@end example\n", aus_daten);
  550.               first_internal=TRUE;
  551.               internal_key[i] = TRUE;
  552.               strcpy(zk1, internal_keywords[i]);
  553.               break;
  554.             }
  555.           } /* Suche nach Keyword */
  556.         }
  557.  
  558.         /* Keyword? */
  559.         if(i!=sizeof(internal_keywords) / sizeof(char**))
  560.         {
  561.           fprintf(aus_daten, "\n@code{%s}\n", zk1);
  562.           fputs("\n@example\n", aus_daten);
  563.         }
  564.         else /* Wir haben kein Schluesselwort */
  565.         {
  566.           if(convert_comment)
  567.           {
  568.             for(i=0; i<strlen(zk1); i++)
  569.               if(zk1[i] == '\\') zk1[i] = '/';
  570.           }
  571.           strcpy(zk, zk1);
  572.           token = zk;
  573.           token = strpbrk(zk," \t");
  574.           switch(last_key)
  575.           {
  576.             case 3:    /* AUTHOR */
  577.           strncpy(author, token, 50);
  578.             break;
  579.  
  580.             case 0:    /* NAME */
  581.           strncpy(project, token, 50);
  582.             break;
  583.  
  584.             case 5:    /* VERSION */
  585.           strncpy(version, token, 50);
  586.             break;
  587.  
  588.             case 1:    /* COPYRIGHT*/
  589.           strncpy(copyright, token, 50);
  590.             break;
  591.           }
  592.           last_key = -1;
  593.           fputs(&zk1[1], aus_daten);
  594.         }
  595.           } /* keine Endkennung */
  596.     } /* fgets() */
  597.     /* Ende mit einlesen -> Kein Fehler, wenn internal == TRUE */
  598.     if(!internal) {
  599.       printf("Error: End of file occured during internal block.\n");
  600.       exit(0);
  601.     }
  602.  
  603.     WriteTexinfo(aus_menue, argv[2], author, project, version,
  604.             copyright, amiga_support);
  605.     fprintf(aus_menue, "* About_%s::\n", zk2);
  606.  
  607.         internal_mode = TRUE;
  608.         autodoc = TRUE;
  609.       } /* Internal-Kennung (AUTHOR, etc.) */
  610.  
  611.     }/* Nicht im Autodoc_modus */
  612.       
  613.   } /* fgets() */
  614.  
  615.   if(autodoc_mode) puts("Error: End of file during autodoc mode!");
  616.   else
  617.   {
  618.     /* Eliminate path specifiers like "/" and ":" */
  619.     for(i=strlen(fname)-1; i>=0; i--)
  620.       if(fname[i] == ':' || fname[i]=='/') break;
  621.     fprintf(aus_menue, "* Function Index::\n@end menu\n\n@include %s\n\n",
  622.             &fname[i+1]);
  623.     fprintf(aus_menue,  "@page\n@node Function Index\n\n"
  624.             "@unnumbered Function Index\n\n"
  625.             "@printindex fn\n@contents\n@bye\n");
  626.     fputs("\n\n", aus_daten);
  627.   }
  628.  
  629. } /* main() */
  630.  
  631.  
  632. /* Eine Extrawurst f"ur den DICE Compiler, der den Start von der WB
  633.    eigenwillig handhabt.  */
  634. #ifdef _DCC
  635. void wbmain(void)
  636. {
  637.   main();
  638. }
  639. #endif
  640.  
  641.  
  642.  
  643.  
  644.  
  645.